Workbench Add-On/Workbench Add-On - Volume 1.iso/Dev/Oberon/source/3rdParty/ARP.mod

Text File | 1995-06-29 | 58.1 KB | 1,449 lines

(*************************************************************************

     $RCSfile: ARP.mod $
  Description: Interface to arp.library

   Created by: fjc (Frank Copeland)
    $Revision: 2.11 $
      $Author: fjc $
        $Date: 1995/06/04 23:11:42 $

  Copyright © 1994-1995, Frank Copeland.
  This file is part of the Oberon-A Library.
  See Oberon-A.doc for conditions of use and distribution.

*************************************************************************)

<* STANDARD- *>

MODULE [2] ARP;

(*
 ************************************************************************
 *                                                                      *
 * 5/3/89       ARPbase.h       by MKSoft from ARPbase.i by SDB         *
 *                                                                      *
 ************************************************************************
 *                                                                      *
 *      AmigaDOS Resource Project -- Library Include File               *
 *                                   for Lattice C 5.x or Manx C 5.x    *
 *                                                                      *
 ************************************************************************
 *                                                                      *
 *      Copyright (c) 1987/1988/1989 by Scott Ballantyne                *
 *                                                                      *
 *      The arp.library, and related code and files may be freely used  *
 *      by supporters of ARP.  Modules in the arp.library may not be    *
 *      extracted for use in independent code, but you are welcome to   *
 *      provide the arp.library with your work and call on it freely.   *
 *                                                                      *
 *      You are equally welcome to add new functions, improve the ones  *
 *      within, or suggest additions.                                   *
 *                                                                      *
 *      BCPL programs are not welcome to call on the arp.library.       *
 *      The welcome mat is out to all others.                           *
 *                                                                      *
 ************************************************************************
 *                                                                      *
 * N O T E !  You MUST! have IoErr() defined as LONG to use LastTracker *
 *            If your compiler has other defines for this, you may wish *
 *            to remove the prototype for IoErr() from this file.       *
 *                                                                      *
 ************************************************************************
 *)

(*
 ************************************************************************
 *      First we need to include the Amiga Standard Include files...    *
 ************************************************************************
 *)


IMPORT
  SYS := SYSTEM, Kernel,
  e := Exec, d := Dos, g := Graphics, i := Intuition, s := Sets;

(* All pointers are declared first for convenience *)

TYPE

  ArpBasePtr *             = POINTER TO ArpBase;
  EnvBasePtr *             = POINTER TO EnvBase;
  FileRequesterPtr *       = POINTER TO FileRequester;
  AnchorPathPtr *          = POINTER TO AnchorPath;
  AChainPtr *              = POINTER TO AChain;
  DirectoryEntryPtr *      = POINTER TO DirectoryEntry;
  TrackedResourcePtr *     = POINTER TO TrackedResource;
  DefaultTrackerPtr *      = POINTER TO DefaultTracker;
  ResListPtr *             = POINTER TO ResList;
  ZombieMsgPtr *           = POINTER TO ZombieMsg;
  ProcessControlBlockPtr * = POINTER TO ProcessControlBlock;
  NewShellPtr *            = POINTER TO NewShell;
  ResidentProgramNodePtr * = POINTER TO ResidentProgramNode;
  ResidentProgramTagPtr *  = POINTER TO ResidentProgramTag;
  ProcessMemoryPtr *       = POINTER TO ProcessMemory;
  DateTimePtr *            = POINTER TO DateTime;


CONST

(*
 ************************************************************************
 *      Standard definitions for arp library information                *
 ************************************************************************
 *)

  arpName *    = "arp.library";   (* Name of library... *)
  arpVersion * = 39;              (* Current version... *)

TYPE

(*
 ************************************************************************
 *      The current ARP library node...                                 *
 ************************************************************************
 *)

  ArpBase * = RECORD (e.LibraryBase)
    libNode *      : e.Library;     (* Standard library node               *)
    dosRootNode *  : d.RootNodePtr; (* Copy of dlRoot                      *)
    abFlags *      : s.SET8;        (* See bitdefs below                   *)
    escChar *      : CHAR;          (* Character to be used for escaping   *)
    arpReserved1 * : LONGINT;       (* ArpLib's use only!!                 *)
    envBase *      : e.LibraryPtr;  (* Dummy library for MANX compatibility*)
    dosBase *      : d.DosLibraryPtr;(* Cached DosBase                      *)
    gfxBase *      : g.GfxBasePtr;  (* Cached GfxBase                      *)
    intuiBase *    : i.IntuitionBasePtr;(* Cached IntuitionBase                *)
    resLists *     : e.MinList;     (* Resource trackers                   *)
    residentPrgList * : ResidentProgramNodePtr; (* Resident Programs.        *)
    resPrgProtection * : e.SignalSemaphore; (* protection for above       *)
    segList *      : e.BPTR;        (* Pointer to loaded libcode (a BPTR). *)
  END; (* ArpBase *)

TYPE

(*
 ***********************************"*"**********************************
 *      The following is here *ONLY* for information and for            *
 *      compatibility with MANX.  DO NOT use in new code!               *
 ************************************************************************
 *)

  EnvBase * = RECORD
    libNode *  : e.Library;  (* Standard library node for linkage    *)
    envSpace * : e.ADDRESS;  (* Access only when Forbidden!          *)
    envSize *  : e.ULONG;    (* Total allocated mem for EnvSpace     *)
    arpBase *  : ArpBasePtr; (* Added in V32 for Resource Tracking   *)
  END; (* EnvBase *)


CONST

(*
 ************************************************************************
 *      These are used in release 33.4 but not by the library code.     *
 *      Instead, individual programs check for these flags.             *
 ************************************************************************
 *)

  arpWildWorld * = 0;              (* Mixed BCPL/Normal wildcards. *)
  arpWildBCPL  * = 1;              (* Pure BCPL wildcards.         *)


CONST

(*
 ************************************************************************
 * The alert object is what you use if you really must return an alert  *
 * to the user. You would normally OR this with another alert number    *
 * from the alerts.h file. Generally, should be NON deadend alerts.     *
 *                                                                      *
 * For example, if you can't open ArpLibrary:                           *
 *      Alert( (AgOpenLib|AoArpLib), 0L);                               *
 ************************************************************************
 *)

  aoArpLib       * = 00008036H;             (* Alert object *)

CONST

(*
 ************************************************************************
 *      Alerts that arp.library may return...                           *
 ************************************************************************
 *)

  anArpLib       * = 03600000H;   (* Alert number                         *)
  anArpNoMem     * = 03610000H;   (* No more memory                       *)
  anArpInputMem  * = 03610002H;   (* No memory for input buffer           *)
  anArpNoMakeEnv * = 83610003H;   (* No memory to make EnvLib             *)

  anArpNoDOS     * = 83630001H;   (* Can't open dos.library               *)
  anArpNoGfx     * = 83630002H;   (* Can't open graphics.library          *)
  anArpNoIntuit  * = 83630003H;   (* Can't open intuition                 *)
  anBadPackBlues * = 83640000H;   (* Bad packet returned to SendPacket()  *)
  anZombie       * = 83600003H;   (* Zombie roaming around system         *)

  anArpScattered * = 83600002H;   (* Scatter loading not allowed for arp  *)


CONST

(*
 ************************************************************************
 *      Return codes you can get from calling ARP Assign()...           *
 ************************************************************************
 *)

  assignOK       * = 0; (* Everything is cool and groovey                *)
  assignNODEV    * = 1; (* "Physical" is not valid for assignment        *)
  assignFATAL    * = 2; (* Something really icky happened                *)
  assignCANCEL   * = 3; (* Tried to cancel something but it won't cancel *)

CONST

(*
 ************************************************************************
 *      Size of buffer you need if you are going to call ReadLine()     *
 ************************************************************************
 *)

  maxInputBuf     * = 256;

TYPE

(*
 ************************************************************************
 *      The ARP file requester data structure...                        *
 ************************************************************************
 *)


  FileRequester * = RECORD
    hail *      : e.ADDRESS;   (* Hailing text                 *)
    file *      : e.ADDRESS;   (* Filename array (FCHARS + 1)  *)
    dir *       : e.ADDRESS;   (* Directory array (DSIZE + 1)  *)
    window *    : i.WindowPtr; (* Window requesting or NULL    *)
    funcFlags * : s.SET8;      (* Set bitdef's below           *)
    flags2 *    : s.SET8;      (* New flags...                 *)
    function *  : PROCEDURE(); (* Your function, see bitdef's  *)
    leftEdge *  : INTEGER;     (* To be used later...          *)
    topEdge *   : INTEGER;
  END; (* FileRequester *)


CONST

(*
 ************************************************************************
 * The following are the defines for frFuncFlags.  These bits tell      *
 * FileRequest() what your frUserFunc is expecting, and what            *
 * FileRequest() should call it for.                                    *
 *                                                                      *
 * You are called like so:                                              *
 * frFunction(Mask, Object)                                             *
 * e.ULONG        Mask;                                                 *
 * e.APTR         *Object;                                              *
 *                                                                      *
 * The Mask is a copy of the flag value that caused FileRequest() to    *
 * call your function. You can use this to determine what action you    *
 * need to perform, and exactly what Object is, so you know what to do  *
 * and what to return.                                                  *
 ************************************************************************
 *)

  doWildFunc  * = 7; (* Call me with a FIB and a name, ZERO return accepts.       *)
  doMsgFunc   * = 6; (* You get all IDCMP messages not for FileRequest()          *)
  doColor     * = 5; (* Set this bit for that new and different look              *)
  newIDCMP    * = 4; (* Force a new IDCMP (only if frWindow != NULL)             *)
  newWindFunc * = 3; (* You get to modify the newwindow structure.                *)
  addGadFunc  * = 2; (* You get to add gadgets.                                   *)
  gEventFunc  * = 1; (* Function to call if one of your gadgets is selected.      *)
  listFunc    * = 0; (* Not implemented yet.                                      *)


CONST

(*
 ************************************************************************
 * The FR2 bits are for frFlags2 in the file requester structure     *
 ************************************************************************
 *)

  longPath   * = 0; (* Specify the frDir buffer is 256 bytes long *)


CONST

(*
 ************************************************************************
 *      The sizes of the different buffers...                           *
 ************************************************************************
 *)

  fChars * = 32;     (* Filename size                              *)
  dSize *  = 33;     (* Directory name size if not FR2LongPath     *)

  longDSize * = 254;    (* If FR2LongPath is set, use longDSIZE    *)
  longFSize * = 126;    (* For compatibility with ARPbase.i        *)

  firstGadget * = 7680H; (* User gadgetID's must be less than this value *)


TYPE

(*
 ************************************************************************
 * Structure expected by FindFirst()/FindNext()                         *
 *                                                                      *
 * You need to allocate this structure and initialize it as follows:    *
 *                                                                      *
 * Set apBreakBits to the signal bits (CDEF) that you want to take a    *
 * break on, or NULL, if you don't want to convenience the user.        *
 *                                                                      *
 * if you want to have the FULL PATH NAME of the files you found,       *
 * allocate a buffer at the END of this structure, and put the size of  *
 * it into apStrLen.  If you don't want the full path name, make sure   *
 * you set apStrLen to zero.  In this case, the name of the file, and   *
 * stats are available in the apInfo, as per usual.                     *
 *                                                                      *
 * Then call FindFirst() and then afterwards, FindNext() with this      *
 * structure.  You should check the return value each time (see below)  *
 * and take the appropriate action, ultimately calling                  *
 * FreeAnchorChain() when there are no more files and you are done.     *
 * You can tell when you are done by checking for the normal AmigaDOS   *
 * return code errorNoMoreENTRIES.                                      *
 *                                                                      *
 * You will also have to check the DirEntryType variable in the apInfo  *
 * structure to determine what exactly you have received.               *
 ************************************************************************
 *)

  AnchorPath * = RECORD
    base *       : AChainPtr; (* Pointer to first anchor                *)
    last *       : AChainPtr; (* Pointer to last anchor                 *)
    breakBits *  : s.SET32;   (* Bits to break on                       *)
    foundBreak * : s.SET32;   (* Bits we broke on. Also returns ERROR_BREAK *)
    flags *      : s.SET8;    (* New use for the extra word...          *)
    reserved *   : SYS.BYTE;  (* To fill it out...                      *)
    strLen *     : INTEGER;   (* This is what used to be apLength       *)
    info *       : d.FileInfoBlock;
  (*buf *        : ARRAY OF SYS.BYTE; (* Allocate a buffer here, if desired *)*)
  END; (* AnchorPath *)

CONST

(*
 ************************************************************************
 *      Bit definitions for the new apFlags...                         *
 ************************************************************************
 *)

  doWild      * = 0;    (* User option ALL                              *)
  itsWild     * = 1;    (* Set by FindFirst, used by FindNext           *)
  doDir       * = 2;    (* Bit is SET if a DIR node should be entered   *)
                        (* Application can RESET this bit po AVOID      *)
                        (* entering a dir.                              *)
  didDir      * = 3;    (* Bit is set for an "expired" dir node         *)
  noMemErr    * = 4;    (* Set if there was not enough memory           *)
  doDot       * = 5;    (* If set, '.' (DOT) will convert to CurrentDir *)


TYPE

(*
 ************************************************************************
 * Structure used by the pattern matching functions, no need to obtain, *
 * diddle or allocate this yourself.                                    *
 *                                                                      *
 * Note:  If you did, you will now break as it has changed...           *
 ************************************************************************
 *)

  AChain * = RECORD
    child *  : AChainPtr;
    parent * : AChainPtr;
    lock *   : d.FileLockPtr;
    info *   : d.FileInfoBlockPtr;
    flags *  : s.SET8;
    string * : ARRAY 1 OF CHAR;   (* Just as is .i file   *)
  END; (* AChain *)               (* ???  Don't use this! *)

CONST

  patternBit  * = 0;
  examinedBit * = 1;
  completed   * = 2;
  allBit      * = 3;


CONST

(*
 ************************************************************************
 * Constants used by wildcard routines                                  *
 *                                                                      *
 * These are the pre-parsed tokens referred to by pattern match.  It    *
 * is not necessary for you to do anything about these, FindFirst()     *
 * FindNext() handle all these for you.                                 *
 ************************************************************************
 *)

  any           * = 80X;   (* Token for '*' | '#?' *)
  single        * = 81X;   (* Token for '?'        *)

CONST

(*
 ************************************************************************
 * No need to muck with these as they may change...                     *
 ************************************************************************
 *)

  orStart       * = 82X;   (* Token for '('        *)
  orNext        * = 83X;   (* Token for '|'        *)
  OrEnd         * = 84X;   (* Token for ')'        *)
  not           * = 85X;   (* Token for '~'        *)
  notClass      * = 87X;   (* Token for '^'        *)
  class         * = 88X;   (* Token for '[]'       *)
  repBeg        * = 89X;   (* Token for '['        *)
  repEnd        * = 8AX;   (* Token for ']'        *)


TYPE

(*
 ************************************************************************
 * Structure used by AddDANode(), AddDADevs(), FreeDAList().            *
 *                                                                      *
 * This structure is used to create lists of names, which normally      *
 * are devices, assigns, volumes, files, or directories.                *
 ************************************************************************
 *)

  DirectoryEntry * = RECORD
    next *  : DirectoryEntryPtr; (* Next in list                      *)
    type *  : SHORTINT;          (* dlxmumble                         *)
    flags * : s.SET8;            (* For future expansion, DO NOT USE! *)
    name *  : ARRAY 256 OF CHAR; (* The name of the thing found       *)
  END; (* DirectoryEntry *)

CONST

(*
 ************************************************************************
 * Defines you use to get a list of the devices you want to look at.    *
 * For example, to get a list of all directories and volumes, do:       *
 *                                                                      *
 *      AddDADevs( mydalist, (DlfDIRS | dlfVOLUMES) )                   *
 *                                                                      *
 * After this, you can examine the detype field of the elements added   *
 * to your list (if any) to discover specifics about the objects added. *
 *                                                                      *
 * Note that if you want only devices which are also disks, you must    *
 * (DlfDEVICES | dlfDISKONLY).                                          *
 ************************************************************************
 *)

  devices     * = 0;      (* Return devices                               *)
  diskOnly    * = 1;      (* Modifier for above: Return disk devices only *)
  volumes     * = 2;      (* Return volumes only                          *)
  dirs        * = 3;      (* Return assigned devices only                 *)


CONST

(*
 ************************************************************************
 * Legal deType values, check for these after a call to AddDADevs(),    *
 * or use on your own as the ID values in AddDANode().                  *
 ************************************************************************
 *)

  file        * = 0;      (* AddDADevs() can't determine this     *)
  dir         * = 8;      (* AddDADevs() can't determine this     *)
  device      * = 16H;    (* It's a resident device               *)
  volume      * = 24H;    (* Device is a volume                   *)
  unmounted   * = 32H;    (* Device is not resident               *)
  assign      * = 40H;    (* Device is a logical assignment       *)

(*
 ************************************************************************
 *      Resource Tracking stuff...                                      *
 ************************************************************************
 *                                                                      *
 * There are a few things in arp.library that are only directly         *
 * acessable from assembler.  The glue routines provided by us for      *
 * all 'C' compilers use the following conventions to make these        *
 * available to C programs.  The glue for other language's should use   *
 * as similar a mechanism as possible, so that no matter what language  *
 * or compiler we speak, when talk about arp, we will know what the     *
 * other guy is saying.                                                 *
 *                                                                      *
 * Here are the cases:                                                  *
 *                                                                      *
 * Tracker calls...                                                     *
 *              These calls return the Tracker pointer as a secondary   *
 *              result in the register A1.  For C, there is no clean    *
 *              way to return more than one result so the tracker       *
 *              pointer is returned in IoErr().  For ease of use,       *
 *              there is a define that typecasts IoErr() to the correct *
 *              pointer type.  This is called LastTracker and should    *
 *              be source compatible with the earlier method of storing *
 *              the secondary result.                                   *
 *                                                                      *
 * GetTracker() -                                                       *
 *              Syntax is a bit different for C than the assembly call  *
 *              The C syntax is GetTracker(ID).  The binding routines   *
 *              will store the ID into the tracker on return.  Also,    *
 *              in an effort to remain consistant, the tracker will     *
 *              also be stored in LastTracker.                          *
 *                                                                      *
 * In cases where you have allocated a tracker before you have obtained *
 * a resource (usually the most efficient method), and the resource has *
 * not been obtained, you will need to clear the tracker id.  The macro *
 * clearID() has been provided for that purpose.  It expects a pointer *
 * to a DefaultTracker sort of struct.                                  *
 ************************************************************************

#define CLEAR_ID(t)     ((SHORT * ) t)[-1]* =NULL

 ************************************************************************
 * You MUST prototype IoErr() to prevent the possible error in defining *
 * IoErr() and thus causing LastTracker to give you trash...            *
 *                                                                      *
 * N O T E !  You MUST! have IoErr() defined as LONG to use LastTracker *
 *            If your compiler has other defines for this, you may wish *
 *            to remove the prototype for IoErr().                      *
 ************************************************************************

#define LastTracker     ((struct DefaultTracker * )IoErr())
*)

TYPE

(*
 ************************************************************************
 * The rlFirstItem list (ResList) is a list of TrackedResource (below)  *
 * It is very important that nothing in this list depend on the task    *
 * existing at resource freeing time (i.e., RemTask(0L) type stuff,     *
 * DeletePort() and the rest).                                          *
 *                                                                      *
 * The tracking functions return a struct Tracker *Tracker to you, this *
 * is a pointer to whatever follows the trID variable.                  *
 * The default case is reflected below, and you get it if you call      *
 * GetTracker() ( see DefaultTracker below).                            *
 *                                                                      *
 * NOTE: The two user variables mentioned in an earlier version don't   *
 * exist, and never did. Sorry about that (SDB).                        *
 *                                                                      *
 * However, you can still use ArpAlloc() to allocate your own tracking  *
 * nodes and they can be any size or shape you like, as long as the     *
 * base structure is preserved. They will be freed automagically just   *
 * like the default trackers.                                           *
 ************************************************************************
 *)

  TrackedResource * = RECORD
    node *   : e.MinNode;      (* Double linked pointer                *)
    flags *  : s.SET8;         (* Don't touch                          *)
    lock *   : SYS.BYTE;       (* Don't touch, for Get/FreeAccess()    *)
    id *     : INTEGER;        (* Item's ID                            *)
(*
 ************************************************************************
 * The struct DefaultTracker *Tracker portion of the structure.         *
 * The stuff below this point can conceivably vary, depending           *
 * on user needs, etc.  This reflects the default.                      *
 ************************************************************************
 *)
    object * : e.ADDRESS;
    extra *  : e.ADDRESS;
  END; (* TrackedResource *)


TYPE

(*
 ************************************************************************
 * You get a pointer to a struct of the following type when you call    *
 * GetTracker().  You can change this, and use ArpAlloc() instead of    *
 * GetTracker() to do tracking. Of course, you have to take a wee bit   *
 * more responsibility if you do, as well as if you use trakGeneric     *
 * stuff.                                                               *
 *                                                                      *
 * trakGeneric folks need to set up a task function to be called when   *
 * an item is freed.  Some care is required to set this up properly.    *
 *                                                                      *
 * Some special cases are indicated by the unions below, for            *
 * trakWindow, if you have more than one window opened, and don't       *
 * want the IDCMP closed particularly, you need to set a ptr to the     *
 * other window in dtWindow2.  See CloseWindowSafely() for more info.   *
 * If only one window, set this to NULL.                                *
 ************************************************************************
 *)

  DefaultTracker * = RECORD
    object * : e.ADDRESS;
    extra *  : e.ADDRESS;
  END; (* DefaultTracker *)

CONST

(*
 ************************************************************************
 *      Items the tracker knows what to do about                        *
 ************************************************************************
 *)

  aAMem      * = 0;      (* Default (ArpAlloc) element           *)
  lock       * = 1;      (* File lock                            *)
  trFile     * = 2;      (* Opened file                          *)
  window     * = 3;      (* Window -- see docs                   *)
  screen     * = 4;      (* Screen                               *)
  library    * = 5;      (* Opened library                       *)
  dAMem      * = 6;      (* Pointer to DosAllocMem block         *)
  memNode    * = 7;      (* AllocEntry() node                    *)
  segList    * = 8;      (* Program segment                      *)
  resList    * = 9;      (* ARP (nested) ResList                 *)
  mem        * = 10;     (* Memory ptr/length                    *)
  generic    * = 11;     (* Generic Element, your choice         *)
  dAList     * = 12;     (* DAlist ( aka file request )          *)
  anchor     * = 13;     (* Anchor chain (pattern matching)      *)
  fReq       * = 14;     (* FileRequest struct                   *)
  font       * = 15;     (* GfxBase CloseFont()                  *)
  max        * = 15;     (* Poof, anything higher is tossed      *)

  unlink      * = 7;      (* Free node bit                        *)
  reloc       * = 6;      (* This may be relocated (not used yet) *)
  moved       * = 5;      (* Item moved                           *)


TYPE

(*
 ************************************************************************
 * Note: ResList MUST be a DosAllocMem'ed list!, this is done for       *
 * you when you call CreateTaskResList(), typically, you won't need     *
 * to access/allocate this structure.                                   *
 ************************************************************************
 *)

  ResList * = RECORD
    node *      : e.MinNode;  (* Used by arplib to link reslists      *)
    taskID *    : e.TaskPtr;  (* Owner of this list                   *)
    firstItem * : e.MinList;  (* List of Tracked Resources            *)
    link *      : ResListPtr; (* SyncRun's use - hide list here       *)
  END; (* ResList *)

CONST

(*
 ************************************************************************
 *      Returns from CompareLock()                                      *
 ************************************************************************
 *)

  equal       * = 0;   (* The two locks refer to the same object       *)
  clVolume    * = 1;   (* Locks are on the same volume                 *)
  difVol1     * = 2;   (* Locks are on different volumes               *)
  difVol2     * = 3;   (* Locks are on different volumes               *)

TYPE

(*
 ************************************************************************
 *      ASyncRun() stuff...                                             *
 ************************************************************************
 * Message sent back on your request by an exiting process.             *
 * You request this by putting the address of your message in           *
 * pcbLastGasp, and initializing the ReplyPort variable of your         *
 * ZombieMsg to the port you wish the message posted to.                *
 ************************************************************************
 *)

  ZombieMsg * = RECORD
    execMessage * : e.Message;
    taskNum *     : e.ULONG; (* Task ID                      *)
    returnCode *  : LONGINT; (* Process's return code        *)
    result2 *     : e.ULONG; (* System return code           *)
    exitTime *    : d.Date;  (* Date stamp at time of exit   *)
    userInfo *    : e.ULONG; (* For whatever you wish        *)
  END; (* ZombieMsg *)

TYPE

(*
 ************************************************************************
 * Structure required by ASyncRun() -- see docs for more info.          *
 ************************************************************************
 *)

  ProcessControlBlock * = RECORD
    stackSize * : e.ULONG;      (* Stacksize for new process                    *)
    pri *       : SHORTINT;     (* Priority of new task                         *)
    control *   : s.SET8;       (* Control bits, see defines below              *)
    trapCode *  : e.ADDRESS;    (* Optional Trap Code                           *)
    input *     : e.BPTR;
    output *    : e.BPTR;       (* Optional stdin, stdout                       *)
    console *   : LONGINT;
    (* console is a union of:
      splatFile * : e.BPTR;     (* File to use for Open("*")                    *)
      conName *   : e.LSTRPTR;  (* CON: filename                                *)
    *)
    loadedCode * : e.ADDRESS;   (* If not null, will not load/unload code       *)
    lastGasp *  : ZombieMsgPtr; (* ReplyMsg() to be filled in by exit           *)
    wbProcess * : e.MsgPort;    (* Valid only when prNOCLI                    *)
  END; (* ProcessControlBlock *)

CONST

(*
 ************************************************************************
 * Formerly needed to pass NULLCMD to a child.  No longer needed.       *
 * It is being kept here for compatibility only...                      *
 ************************************************************************
 *)

  NoCmd   * = "\n";

CONST

(*
 ************************************************************************
 * The following control bits determine what ASyncRun() does on         *
 * Abnormal Exits and on background process termination.                *
 ************************************************************************
 *)

  saveIO      * = 0;    (* Don't free/check file handles on exit        *)
  closeSplat  * = 1;    (* Close Splat file, must request explicitly    *)
  noCLI       * = 2;    (* Don't create a CLI process                   *)
(*interactive * = 3;       This is now obsolete...                      *)
  code        * = 4;    (* Dangerous yet enticing                       *)
  stdio       * = 5;    (* Do the stdio thing, splat * = CON:Filename   *)


CONST

(*
 ************************************************************************
 *      Error returns from SyncRun() and ASyncRun()                     *
 ************************************************************************
 *)

  noFile   * = -1;     (* Could not LoadSeg() the file                 *)
  noMem    * = -2;     (* No memory for something                      *)
(*noCLI      = -3;       This is now obsolete                          *)
  noSlot   * = -4;     (* No room in TaskArray                         *)
  noInput  * = -5;     (* Could not open input file                    *)
  noOutput * = -6;     (* Could not get output file                    *)
(*noLock     = -7;        This is now obsolete                         *)
(*argErr     = -8;        This is now obsolete                         *)
(*noBCPL     = -9;        This is now obsolete                         *)
(*badLib     = -10;       This is now obsolete                         *)
  noStdio  * = -11;    (* Couldn't get stdio handles                   *)

CONST

(*
 ************************************************************************
 *      Added V35 of arp.library                                        *
 ************************************************************************
 *)

  wantSMessage * = -12; (* Child wants you to report IoErr() to user    *)
                          (* for SyncRun() only...                        *)
  noShellProc  * = -13; (* Can't create a shell/cli process             *)
  noExec       * = -14; (* 'E' bit is clear                             *)
  script       * = -15; (* S and E are set, IoErr() contains directory  *)

TYPE

(*
 ************************************************************************
 * Version 35 ASyncRun() allows you to create an independent            *
 * interactive or background Shell/CLi. You need this variant of the    *
 * pcb structure to do it, and you also have new values for nshControl, *
 * see below.                                                           *
 *                                                                      *
 * Syntax for Interactive shell is:                                     *
 *                                                                      *
 * rc=ASyncRun("Optional Window Name","Optional From File",&NewShell);  *
 *                                                                      *
 * Syntax for a background shell is:                                    *
 *                                                                      *
 * rc=ASyncRun("Command line",0L,&NewShell);                            *
 *                                                                      *
 * Same syntax for an Execute style call, but you have to be on drugs   *
 * if you want to do that.                                              *
 ************************************************************************
 *)

  NewShell * = RECORD
    stackSize * : e.ULONG;  (* stacksize shell will use for children        *)
    pri *       : SHORTINT; (* ignored by interactive shells                *)
    control *   : s.SET8;   (* bits/values: see above                       *)
    logMsg *    : e.ADDRESS;(* Optional login message, if null, use default *)
    input *     : e.BPTR;   (* ignored by interactive shells, but           *)
    output *    : e.BPTR;   (* used by background and execute options.      *)
    reserved *  : ARRAY 5 OF LONGINT;
  END; (* NewShell *)

CONST

(*
 ************************************************************************
 * Bit Values for nshControl, you should use them as shown below, or    *
 * just use the actual values indicated.                                *
 ************************************************************************
 *)

  cli         * = 0;      (* Do a CLI, not a shell        *)
  backGround  * = 1;      (* Background shell             *)
  execute     * = 2;      (* Do as EXECUTe...             *)
  interactive * = 3;      (* Run an interactive shell     *)
  fb          * = 7;      (* Alt function bit...          *)


CONST

(*
 ************************************************************************
 *      Common values for shControl which allow you to do usefull      *
 *      and somewhat "standard" things...                               *
 ************************************************************************
 *)

  interactiveShell * = { fb, interactive };         (* Gimme a newshell!            *)
  interactiveCLI   * = { fb, interactive, cli };    (* Gimme that ol newcli!        *)
  backgroundShell  * = { fb, backGround };          (* gimme a background shell     *)
  executeMe        * = { fb, backGround, execute }; (* aptly named, doncha think?   *)

CONST

(*
 ************************************************************************
 *      Additional IoErr() returns added by ARP...                      *
 ************************************************************************
 *)

  errorBufferOverflow   * = 303;    (* User or internal buffer overflow     *)
  errorBreak            * = 304;    (* A break character was received       *)
  errorNotExecutable    * = 305;    (* A file has E bit cleared             *)
  errorNotCLI           * = 400;    (* Program/function neeeds to be cli    *)

TYPE

(*
 ************************************************************************
 *      Resident Program Support                                        *
 ************************************************************************
 * This is the kind of node allocated for you when you AddResidentPrg() *
 * a code segment.  They are stored as a single linked list with the    *
 * root in ArpBase.  If you absolutely *must* wander through this list  *
 * instead of using the supplied functions, then you must first obtain  *
 * the semaphore which protects this list, and then release it          *
 * afterwards.  Do not use Forbid() and Permit() to gain exclusive      *
 * access!  Note that the supplied functions handle this locking        *
 * protocol for you.                                                    *
 ************************************************************************
 *)

  ResidentProgramNode * = RECORD
    next *      : ResidentProgramNodePtr; (* next or NULL        *)
    usage *     : LONGINT;       (* Number of current users      *)
    accessCnt * : e.UWORD;       (* Total times used...          *)
    checkSum *  : e.ULONG;       (* Checksum of code             *)
    segment *   : e.BPTR;        (* Actual segment               *)
    flags *     : s.SET16;       (* See definitions below...     *)
  (*name *      : ARRAY OF CHAR; (* Allocated as needed          *)*)
  END; (* ResidentProgramNode *)

CONST

(*
 ************************************************************************
 *      Bit definitions for rpnFlags....                                *
 ************************************************************************
 *)

  noCheck * = 0;      (* Set in rpnFlags for no checksumming...      *)
  cache *   = 1;      (* Private usage in v1.3...                    *)


TYPE

(*
 ************************************************************************
 * If your program starts with this structure, ASyncRun() and SyncRun() *
 * will override a users stack request with the value in rptStackSize.  *
 * Furthermore, if you are actually attached to the resident list, a    *
 * memory block of size rptDataSize will be allocated for you, and      *
 * a pointer to this data passed to you in register A4.  You may use    *
 * this block to clone the data segment of programs, thus resulting in  *
 * one copy of text, but multiple copies of data/bss for each process   *
 * invocation.  If you are resident, your program will start at         *
 * rptInstruction, otherwise, it will be launched from the initial      *
 * branch.                                                              *
 ************************************************************************
 *)

  ResidentProgramTag * = RECORD
    nextSeg *   : e.BPTR;    (* Provided by DOS at LoadSeg time      *)
(*
 ************************************************************************
 * The initial branch destination and rptInstruction do not have to be *
 * the same.  This allows different actions to be taken if you are      *
 * diskloaded or resident.  DataSize memory will be allocated only if   *
 * you are resident, but StackSize will override all user stack         *
 * requests.                                                            *
 ************************************************************************
 *)
    bra *       : e.UWORD; (* Short branch to executable           *)
    magic *     : e.UWORD; (* Resident majik value                 *)
    stackSize * : e.ULONG; (* min stack for this process           *)
    dataSize *  : e.ULONG; (* Data size to allocate if resident    *)
    (*      instruction;        Start here if resident          *)
  END; (* ResidentProgramTag *)

TYPE

(*
 ************************************************************************
 * The form of the ARP allocated node in your tasks memlist when        *
 * launched as a resident program. Note that the data portion of the    *
 * node will only exist if you have specified a nonzero value for       *
 * rptDataSize. Note also that this structure is READ ONLY, modify     *
 * values in this at your own risk.  The stack stuff is for tracking,   *
 * if you need actual addresses or stack size, check the normal places  *
 * for it in your process/task struct.                                  *
 ************************************************************************
 *)

  ProcessMemory * = RECORD
    node *      : e.Node;
    num *       : e.UWORD; (* This is 1 if no data, two if data    *)
    stack *     : e.APTR;
    stackSize * : e.ULONG;
    data *      : e.APTR;  (* Only here if pmNum == 2              *)
    dataSize *  : e.ULONG;
  END; (* ProcessMemory *)

CONST

(*
 ************************************************************************
 * To find the above on your memlist, search for the following name.    *
 * We guarantee this will be the only arp.library allocated node on     *
 * your memlist with this name.                                         *
 * i.e. FindName(task->tcbMemEntry, pmemNAME);                        *
 ************************************************************************
 *)

  pMemName       * = "ARP_MEM";

  residentMagic  * = 4AFCH;          (* same as rtcMATCHWORD (trapf) *)

TYPE

(*
 ************************************************************************
 *      Date String/Data structures                                     *
 ************************************************************************
 *)

  DateTime * = RECORD
    stamp *   : d.Date;     (* DOS Datestamp                        *)
    format *  : SYS.BYTE;   (* controls appearance ot datStrDate    *)
    flags *   : s.SET8;     (* See BITDEF's below                   *)
    strDay *  : e.ADDRESS;  (* day of the week string               *)
    strDate * : e.ADDRESS;  (* date string                          *)
    strTime * : e.ADDRESS;  (* time string                          *)
  END; (* DateTime *)

CONST

(*
 ************************************************************************
 *      Size of buffer you need for each DateTime strings:              *
 ************************************************************************
 *)

  lenDatString   * = 10;

CONST

(*
 ************************************************************************
 *      For datFlags                                                   *
 ************************************************************************
 *)

  subSt  * = 0; (* Substitute "Today" "Tomorrow" where appropriate      *)
  future * = 1; (* Day of the week is in future                         *)


CONST

(*
 ************************************************************************
 *      For datFormat                                                  *
 ************************************************************************
 *)

  formatDos * = 0;         (* dd-mmm-yy AmigaDOS's own, unique style               *)
  formatInt * = 1;         (* yy-mm-dd International format                        *)
  formatUSA * = 2;         (* mm-dd-yy The good'ol'USA.                            *)
  formatCDN * = 3;         (* dd-mm-yy Our brothers and sisters to the north       *)
  formatMAX * = formatCDN; (* Larger than this? Defaults to AmigaDOS               *)


(* --- Library Base variable -------------------------------------------- *)


VAR

  arp *, base *  : ArpBasePtr;


(* --- Library Functions ------------------------------------------------ *)

TYPE

  PROC * = PROCEDURE();

(*
 ************************************************************************
 *  These duplicate the calls in dos.library                            *
 *  Only include if you can use arp.library without dos.library         *
 ************************************************************************
 *)


PROCEDURE Open* [base,-30]
  ( name       [1] : ARRAY OF CHAR;
    accessMode [2] : LONGINT)
  : d.FileHandlePtr;
PROCEDURE Close* [base,-36]
  ( file [1] : d.FileHandlePtr );
PROCEDURE Read* [base,-42]
  ( file       [1] : d.FileHandlePtr;
    VAR buffer [2] : ARRAY OF SYS.BYTE;
    length     [3] : LONGINT)
  : LONGINT;
PROCEDURE Write* [base,-48]
  ( file   [1] : d.FileHandlePtr;
    buffer [2] : ARRAY OF SYS.BYTE;
    length [3] : LONGINT)
  : LONGINT;
PROCEDURE Input* [base,-54] ()
  : d.FileHandlePtr;
PROCEDURE Output* [base,-60] ()
  : d.FileHandlePtr;
PROCEDURE Seek* [base,-66]
  ( file     [1] : d.FileHandlePtr;
    position [2] : LONGINT;
    offset   [3] : LONGINT)
  : LONGINT;
PROCEDURE DeleteFile* [base,-72]
  ( name [1] : ARRAY OF CHAR )
  : BOOLEAN;
PROCEDURE Rename* [base,-78]
  ( oldName [1] : ARRAY OF CHAR;
    newName [2] : ARRAY OF CHAR )
  : BOOLEAN;
PROCEDURE Lock* [base,-84]
  ( name [1] : ARRAY OF CHAR;
    type [2] : LONGINT)
  : d.FileLockPtr;
PROCEDURE UnLock* [base,-90]
  ( lock [1] : d.FileLockPtr );
PROCEDURE DupLock* [base,-96]
  ( lock [1] : d.FileLockPtr )
  : d.FileLockPtr;
PROCEDURE Examine* [base,-102]
  ( lock          [1] : d.FileLockPtr;
    fileInfoBlock [2] : d.FileInfoBlockPtr )
  : BOOLEAN;
PROCEDURE ExNext* [base,-108]
  ( lock          [1] : d.FileLockPtr;
    fileInfoBlock [2] : d.FileInfoBlockPtr )
  : BOOLEAN;
PROCEDURE Info* [base,-114]
  ( lock           [1] : d.FileLockPtr;
    parameterBlock [2] : d.InfoDataPtr )
  : BOOLEAN;
PROCEDURE CreateDir* [base,-120]
  ( name [1] : ARRAY OF CHAR )
  : d.FileLockPtr;
PROCEDURE CurrentDir* [base,-126]
  ( lock [1] : d.FileLockPtr )
  : d.FileLockPtr;
PROCEDURE IoErr* [base,-132] ()
  : LONGINT;
PROCEDURE CreateProc* [base,-138]
  ( name      [1] : ARRAY OF CHAR;
    pri       [2] : LONGINT;
    segList   [3] : e.BPTR;
    stackSize [4] : LONGINT)
  : e.MsgPortPtr;
PROCEDURE Exit* [base,-144]
  ( returnCode [1] : LONGINT);
PROCEDURE LoadSeg* [base,-150]
  ( name [1] : ARRAY OF CHAR )
  : e.BPTR;
PROCEDURE UnLoadSeg* [base,-156]
  ( seglist [1] : e.BPTR );
PROCEDURE DeviceProc* [base,-174]
  ( name [1] : ARRAY OF CHAR )
  : e.MsgPortPtr;
PROCEDURE SetComment* [base,-180]
  ( name    [1] : ARRAY OF CHAR;
    comment [2] : ARRAY OF CHAR )
  : BOOLEAN;
PROCEDURE SetProtection* [base,-186]
  ( name    [1] : ARRAY OF CHAR;
    protect [2] : s.SET32)
  : BOOLEAN;
PROCEDURE DateStamp* [base,-192]
  ( VAR date [1] : d.DateBase );
PROCEDURE Delay* [base,-198]
  ( timeout [1] : e.ULONG);
PROCEDURE WaitForChar* [base,-204]
  ( file    [1] : d.FileHandlePtr;
    timeout [2] : LONGINT)
  : BOOLEAN;
PROCEDURE ParentDir* [base,-210]
  ( lock [1] : d.FileLockPtr )
  : d.FileLockPtr;
PROCEDURE IsInteractive* [base,-216]
  ( file [1] : d.FileHandlePtr )
  : BOOLEAN;
PROCEDURE Execute* [base,-222]
  ( string [1] : ARRAY OF CHAR;
    file   [2] : d.FileHandlePtr;
    file2  [3] : d.FileHandlePtr )
  : LONGINT;


(*
 ************************************************************************
 * Now for the stuff that only exists in arp.library...                 *
 ************************************************************************
 *)

PROCEDURE VPrintf* [base,-228]
  ( string [8] : ARRAY OF CHAR;
    args   [9] : ARRAY OF e.ADDRESS )
  : LONGINT;
PROCEDURE Printf* [base,-228]
  ( string [8]  : ARRAY OF CHAR;
    args   [9]..: e.APTR )
  : LONGINT;
PROCEDURE VFPrintf* [base,-234]
  ( file   [0] : d.FileHandlePtr;
    string [8] : ARRAY OF CHAR;
    args   [9] : ARRAY OF e.APTR )
  : LONGINT;
PROCEDURE FPrintf* [base,-234]
  ( file   [0]  : d.FileHandlePtr;
    string [8]  : ARRAY OF CHAR;
    args   [9]..: e.APTR )
  : LONGINT;
PROCEDURE Puts* [base,-240]
  ( string [9] : ARRAY OF CHAR )
  : LONGINT;
PROCEDURE ReadLine* [base,-246]
  ( VAR string [8] : ARRAY OF CHAR )
  : LONGINT;
PROCEDURE GADS* [base,-252]
  ( line      [8] : ARRAY OF CHAR;
    len       [0] : LONGINT;
    help      [9] : e.ADDRESS;
    VAR args [10] : ARRAY OF SYS.LONGWORD;
    temp     [11] : ARRAY OF CHAR )
  : LONGINT;
PROCEDURE Atol* [base,-258]
  ( string [8] : ARRAY OF CHAR )
  : LONGINT;
PROCEDURE EscapeString* [base,-264]
  ( string [8] : ARRAY OF CHAR )
  : e.ULONG;
PROCEDURE CheckAbort* [base,-270]
  ( func [9] : e.PROC )
  : LONGINT;
PROCEDURE CheckBreak* [base,-276]
  ( mask [1] : s.SET32;
    func [9] : e.PROC )
  : LONGINT;
PROCEDURE Getenv* [base,-282]
  ( string     [8] : ARRAY OF CHAR;
    VAR buffer [9] : ARRAY OF CHAR;
    size       [0] : LONGINT )
  : e.ADDRESS;
PROCEDURE Setenv* [base,-288]
  ( varName [8] : ARRAY OF CHAR;
    value   [9] : ARRAY OF CHAR )
  : BOOLEAN;
PROCEDURE FileRequest* [base,-294]
  ( VAR fileRequester [8] : FileRequester )
  : e.ADDRESS;
PROCEDURE CloseWindowSafely* [base,-300]
  ( window      [8] : i.WindowPtr;
    moreWindows [9] : i.WindowPtr );
PROCEDURE CreatePort* [base,-306]
  ( name [8] : ARRAY OF CHAR;
    pri  [0] : LONGINT )
  : e.MsgPortPtr;
PROCEDURE DeletePort* [base,-312]
  ( port [9] : e.MsgPortBasePtr );
PROCEDURE SendPacket* [base,-318]
  ( action  [0] : LONGINT;
    args    [8] : e.ADDRESS;
    handler [9] : e.MsgPortBasePtr )
  : LONGINT;
PROCEDURE InitStdPacket* [base,-324]
  ( action     [0] : LONGINT;
    args       [8] : e.ADDRESS;
    packet     [9] : d.DosPacketPtr;
    replyPort [10] : e.MsgPortBasePtr );
PROCEDURE PathName* [base,-330]
  ( lock           [0] : d.FileLockPtr;
    VAR buffer     [8] : ARRAY OF CHAR;
    componentCount [1] : LONGINT )
  : e.ULONG;
PROCEDURE Assign* [base,-336]
  ( logical  [8] : ARRAY OF CHAR;
    physical [9] : ARRAY OF CHAR )
  : e.ULONG;
PROCEDURE DosAllocMem* [base,-342]
  ( size [0] : LONGINT )
  : e.APTR;
PROCEDURE DosFreeMem* [base,-348]
  ( block [9] : e.APTR );
PROCEDURE BtoCStr* [base,-354]
  ( VAR cstr  [8] : ARRAY OF CHAR;
    bstr      [0] : d.BSTR;
    maxLength [1] : LONGINT )
  : e.ULONG;
PROCEDURE CtoBStr* [base,-360]
  ( cstr      [8] : ARRAY OF CHAR;
    VAR bstr  [0] : d.BSTR;
    maxLength [1] : LONGINT )
  : e.ULONG;
PROCEDURE GetDevInfo* [base,-366]
  ( devNode [10] : d.DeviceListPtr )
  : d.DeviceListPtr;
PROCEDURE FreeTaskResList* [base,-372] ()
  : BOOLEAN;
PROCEDURE ArpExit* [base,-378]
  ( rc    [0] : LONGINT;
    fault [2] : LONGINT );
PROCEDURE ArpAlloc* [base,-384]
  ( size [0] : LONGINT )
  : e.ADDRESS;
PROCEDURE ArpAllocMem* [base,-390]
  ( size         [0] : LONGINT;
    requirements [1] : s.SET32 )
  : e.ADDRESS;
PROCEDURE ArpOpen* [base,-396]
  ( name [1] : ARRAY OF CHAR;
    mode [2] : LONGINT )
  : d.FileHandlePtr;
PROCEDURE ArpDupLock* [base,-402]
  ( lock [1] : d.FileLockPtr )
  : d.FileLockPtr;
PROCEDURE ArpLock* [base,-408]
  ( name [1] : ARRAY OF CHAR;
    mode [2] : LONGINT )
  : d.FileLockPtr;
PROCEDURE RListAlloc* [base,-414]
  ( resList [8] : ResListPtr;
    size    [0] : LONGINT )
  : e.ADDRESS;
PROCEDURE FindCLI* [base,-420]
  ( cliNum [0] : LONGINT )
  : e.APTR;
PROCEDURE QSort* [base,-426]
  ( data  [8] : e.APTR;
    rSize [0] : LONGINT;
    bSize [1] : LONGINT;
    comp  [9] : e.PROC )
  : BOOLEAN;
PROCEDURE PatternMatch* [base,-432]
  ( pattern [8] : ARRAY OF CHAR;
    string  [9] : ARRAY OF CHAR )
  : BOOLEAN;
PROCEDURE FindFirst* [base,-438]
  ( pattern  [0] : ARRAY OF CHAR;
    VAR path [8] : AnchorPath )
  : LONGINT;
PROCEDURE FindNext* [base,-444]
  ( VAR path [8] : AnchorPath )
  : LONGINT;
PROCEDURE FreeAnchorChain* [base,-450]
  ( VAR path [8] : AnchorPath );
PROCEDURE CompareLock* [base,-456]
  ( lock1 [0] : d.FileLockPtr;
    lock2 [1] : d.FileLockPtr )
  : e.ULONG;
PROCEDURE FindTaskResList* [base,-462] ()
  : ResListPtr;
PROCEDURE CreateTaskResList* [base,-468] ()
  : ResListPtr;
PROCEDURE FreeResList* [base,-474]
  ( freeList [9] : ResListPtr );
PROCEDURE FreeTrackedItem* [base,-480]
  ( item [9] : DefaultTrackerPtr );
PROCEDURE GetTracker* [base,-486]
  ( size [9] : LONGINT )
  : DefaultTrackerPtr;
PROCEDURE GetAccess* [base,-492]
  ( tracker [9] : DefaultTrackerPtr )
  : e.APTR;
PROCEDURE FreeAccess* [base,-498]
  ( tracker [9] : DefaultTrackerPtr );
PROCEDURE FreeDAList* [base,-504]
  ( VAR node [9] : DirectoryEntry );
PROCEDURE AddDANode* [base,-510]
  ( data       [8] : ARRAY OF CHAR;
    VAR daList [9] : DirectoryEntry;
    length     [0] : LONGINT;
    id         [1] : LONGINT )
  : DirectoryEntryPtr;
PROCEDURE AddDADevs* [base,-516]
  ( VAR daList [8] : DirectoryEntry;
    select     [0] : s.SET32 )
  : e.ULONG;
PROCEDURE Strcmp* [base,-522]
  ( s1 [8] : ARRAY OF CHAR;
    s2 [9] : ARRAY OF CHAR )
  : LONGINT;
PROCEDURE Strncmp* [base,-528]
  ( s1     [8] : ARRAY OF CHAR;
    s2     [9] : ARRAY OF CHAR;
    length [0] : LONGINT )
  : LONGINT;
PROCEDURE ToUpper* [base,-534]
  ( char [0] : CHAR )
  : CHAR;
PROCEDURE SyncRun* [base,-540]
  ( name    [8] : ARRAY OF CHAR;
    command [9] : e.ADDRESS;
    input   [0] : d.FileHandlePtr;
    output  [1] : d.FileHandlePtr )
  : LONGINT;

(*
 ************************************************************************
 *  Added V32 of arp.library                                            *
 ************************************************************************
 *)

PROCEDURE ASyncRun* [base,-546]
  ( name     [8] : ARRAY OF CHAR;
    command  [9] : e.ADDRESS;
    VAR pcb [10] : ProcessControlBlock )
  : LONGINT;
PROCEDURE SpawnShell* [base,-546]
  ( name       [8] : ARRAY OF CHAR;
    command    [9] : e.ADDRESS;
    VAR shell [10] : NewShell )
  : LONGINT;
PROCEDURE LoadPrg* [base,-552]
  ( name [1] : ARRAY OF CHAR )
  : e.BPTR;
PROCEDURE PreParse* [base,-558]
  ( source   [8] : ARRAY OF CHAR;
    VAR dest [9] : ARRAY OF CHAR )
  : BOOLEAN;

(*
 ************************************************************************
 * Added V33 of arp.library                                             *
 ************************************************************************
 *)

PROCEDURE StamptoStr* [base,-564]
  ( VAR dateTime [8] : DateTime )
  : BOOLEAN;
PROCEDURE StrtoStamp* [base,-570]
  ( VAR dateTime [8] : DateTime )
  : BOOLEAN;
PROCEDURE ObtainResidentPrg* [base,-576]
  ( name [8] : ARRAY OF CHAR )
  : ResidentProgramNodePtr;
PROCEDURE AddResidentPrg* [base,-582]
  ( segment [1] : e.BPTR;
    name    [8] : ARRAY OF CHAR )
  : ResidentProgramNodePtr;
PROCEDURE RemResidentPrg* [base,-588]
  ( name [8] : ARRAY OF CHAR )
  : LONGINT;
PROCEDURE UnLoadPrg* [base,-594]
  ( segment [1] : e.BPTR );
PROCEDURE LMult* [base,-600]
  ( a [0] : LONGINT;
    b [1] : LONGINT )
  : LONGINT;
PROCEDURE LDiv* [base,-606]
  ( a [0] : LONGINT;
    b [1] : LONGINT )
  : LONGINT;
PROCEDURE LMod* [base,-612]
  ( a [0] : LONGINT;
    b [1] : LONGINT )
  : LONGINT;
PROCEDURE CheckSumPrg* [base,-618]
  ( VAR node [0] : ResidentProgramNode )
  : e.ULONG;
PROCEDURE TackOn* [base,-624]
  ( VAR pathname [8] : ARRAY OF CHAR;
    filename     [9] : ARRAY OF CHAR );
PROCEDURE BaseName* [base,-630]
  ( name [8] : ARRAY OF CHAR )
  : e.ADDRESS;
PROCEDURE ReleaseResidentPrg* [base,-636]
  ( segment [1] : e.BPTR )
  : ResidentProgramNodePtr;

(*
 ************************************************************************
 * Added V36 of arp.library                                             *
 ************************************************************************
 *)

PROCEDURE SPrintf* [base,-642]
  ( file   [0] : e.ADDRESS;
    string [8] : ARRAY OF CHAR;
    stream [9] : e.ADDRESS )
  : LONGINT;
PROCEDURE GetKeywordIndex* [base,-648]
  ( key      [8] : ARRAY OF CHAR;
    template [9] : ARRAY OF CHAR )
  : LONGINT;
PROCEDURE ArpOpenLibrary* [base,-654]
  ( name    [9] : ARRAY OF CHAR;
    version [0] : LONGINT )
  : e.LibraryPtr;
PROCEDURE ArpAllocFreq* [base,-660] ()
  : FileRequesterPtr;


(* --- Library Base variable -------------------------------------------- *)
<*$LongVars-*>

(*------------------------------------*)
PROCEDURE* [0] CloseLib (VAR rc : LONGINT);

BEGIN (* CloseLib *)
  IF base # NIL THEN e.CloseLibrary (base) END
END CloseLib;

BEGIN (* ARP *)
  base := SYS.VAL (ArpBasePtr,
                   e.OpenLibrary (arpName, arpVersion));
  IF base = NIL THEN HALT (100) END;
  arp := base; Kernel.SetCleanup (CloseLib)
END ARP.